package com.xinqi.common.base.utils.number;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * bigDecimal工具类
 *
 * @author linkai
 * @date 2022/11/25
 */
public interface BigDecimals {

    int DEFAULT_SCALE = 2;

    /**
     * <p/> UP：向远离零的方向舍入，即正数向正无穷大舍入，负数向负无穷大舍入。
     * <p/> DOWN：向接近零的方向舍入，即正数向负无穷大舍入，负数向正无穷大舍入。
     * <p/> CEILING：向正无穷大方向舍入。
     * <p/> FLOOR：向负无穷大方向舍入。
     * <p/> HALF_UP：四舍五入，向最接近的整数舍入，如果两个相邻的整数同样接近，则舍入到偶数。
     * <p/> HALF_DOWN：五舍六入，向最接近的整数舍入，如果两个相邻的整数同样接近，则舍入到偶数。
     * <p/> HALF_EVEN：银行家舍入法，四舍六入五成双，向最接近的偶数舍入。
     * <p/> UNNECESSARY：不需要舍入，如果对结果进行舍入会产生非零位，则抛出 ArithmeticException。
     */
    RoundingMode ROUNDING_MODE = RoundingMode.HALF_UP;

    /**
     * 等于 ( == )
     */
    static boolean eq(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) == 0;
    }

    /**
     * 不等于 ( <> )
     */
    static boolean ne(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) != 0;
    }

    /**
     * 大于 ( > )
     */
    static boolean gt(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) > 0;
    }

    /**
     * 大于等于 ( >= )
     */
    static boolean goe(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) >= 0;
    }

    /**
     * 小于 ( < )
     */
    static boolean lt(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) < 0;
    }

    /**
     * 小于等于 ( <= )
     */
    static boolean loe(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) <= 0;
    }

    static BigDecimal zero() {
        return BigDecimal.ZERO;
    }

    static BigDecimal one() {
        return BigDecimal.ONE;
    }

    /**
     * 加
     */
    static BigDecimal add(BigDecimal a, BigDecimal b) {
        return a.add(b);
    }

    /**
     * 减
     */
    static BigDecimal subtract(BigDecimal a, BigDecimal b) {
        return a.subtract(b);
    }

    /**
     * 乘
     */
    static BigDecimal multiply(BigDecimal a, BigDecimal b) {
        return a.multiply(b);
    }

    /**
     * 乘
     */
    static BigDecimal multiply(BigDecimal a, Integer b) {
        return a.multiply(new BigDecimal(b));
    }

    /**
     * 取反
     */
    static BigDecimal negative(BigDecimal num) {
        return subtract(BigDecimal.ZERO, num.abs());
    }

    /**
     * 除
     */
    static BigDecimal divide(BigDecimal a, BigDecimal b) {
        return a.divide(b, DEFAULT_SCALE, ROUNDING_MODE);
    }

    /**
     * 除
     */
    static BigDecimal divide(BigDecimal a, int b) {
        return a.divide(new BigDecimal(b), DEFAULT_SCALE, ROUNDING_MODE);
    }

    /**
     * 除
     */
    static BigDecimal divide(int a, int b) {
        return new BigDecimal(a).divide(new BigDecimal(b), DEFAULT_SCALE, ROUNDING_MODE);
    }

    /**
     * 除
     */
    static BigDecimal divide(BigDecimal a, BigDecimal b, int scale, RoundingMode roundingMode) {
        return a.divide(b, scale, roundingMode);
    }


    static String toString(BigDecimal a) {
        if (a == null) {
            return null;
        }
        return a.stripTrailingZeros().toPlainString();
    }

    /**
     * 分数格式化
     */
    static String scoreFormat(BigDecimal a) {
        if (a == null) {
            return null;
        }
        return formatScore(a).stripTrailingZeros().toPlainString();
    }

    /**
     * 分数格式化
     */
    static BigDecimal formatScore(BigDecimal a) {
        if (a == null) {
            return null;
        }
        return a.setScale(1, RoundingMode.HALF_UP);
    }


    static BigDecimal min(BigDecimal studentScore, BigDecimal score) {
        return studentScore.compareTo(score) < 0 ? studentScore : score;
    }

    static boolean isZero(BigDecimal studentScore) {
        return studentScore.compareTo(BigDecimal.ZERO) == 0;
    }

}
